home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / gtk-2.0 / gtk / gtkcellrenderer.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-25  |  6.0 KB  |  171 lines
  1. /* gtkcellrenderer.h
  2.  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Library General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * Library General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Library General Public
  15.  * License along with this library; if not, write to the
  16.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17.  * Boston, MA 02111-1307, USA.
  18.  */
  19.  
  20. #ifndef __GTK_CELL_RENDERER_H__
  21. #define __GTK_CELL_RENDERER_H__
  22.  
  23. #include <gtk/gtkobject.h>
  24. #include <gtk/gtkwidget.h>
  25. #include <gtk/gtkcelleditable.h>
  26.  
  27. G_BEGIN_DECLS
  28.  
  29. typedef enum
  30. {
  31.   GTK_CELL_RENDERER_SELECTED    = 1 << 0,
  32.   GTK_CELL_RENDERER_PRELIT      = 1 << 1,
  33.   GTK_CELL_RENDERER_INSENSITIVE = 1 << 2,
  34.   /* this flag means the cell is in the sort column/row */
  35.   GTK_CELL_RENDERER_SORTED      = 1 << 3,
  36.   GTK_CELL_RENDERER_FOCUSED     = 1 << 4
  37. } GtkCellRendererState;
  38.  
  39. typedef enum
  40. {
  41.   GTK_CELL_RENDERER_MODE_INERT,
  42.   GTK_CELL_RENDERER_MODE_ACTIVATABLE,
  43.   GTK_CELL_RENDERER_MODE_EDITABLE
  44. } GtkCellRendererMode;
  45.  
  46. #define GTK_TYPE_CELL_RENDERER          (gtk_cell_renderer_get_type ())
  47. #define GTK_CELL_RENDERER(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRenderer))
  48. #define GTK_CELL_RENDERER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
  49. #define GTK_IS_CELL_RENDERER(obj)      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER))
  50. #define GTK_IS_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER))
  51. #define GTK_CELL_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
  52.  
  53. typedef struct _GtkCellRenderer GtkCellRenderer;
  54. typedef struct _GtkCellRendererClass GtkCellRendererClass;
  55.  
  56. struct _GtkCellRenderer
  57. {
  58.   GtkObject parent;
  59.  
  60.   gfloat xalign;
  61.   gfloat yalign;
  62.  
  63.   gint width;
  64.   gint height;
  65.  
  66.   guint16 xpad;
  67.   guint16 ypad;
  68.  
  69.   guint mode : 2;
  70.   guint visible : 1;
  71.   guint is_expander : 1;
  72.   guint is_expanded : 1;
  73.   guint cell_background_set : 1;
  74.   guint sensitive : 1;
  75.   guint editing : 1;
  76. };
  77.  
  78. struct _GtkCellRendererClass
  79. {
  80.   GtkObjectClass parent_class;
  81.  
  82.   /* vtable - not signals */
  83.   void             (* get_size)      (GtkCellRenderer      *cell,
  84.                       GtkWidget            *widget,
  85.                       GdkRectangle         *cell_area,
  86.                       gint                 *x_offset,
  87.                       gint                 *y_offset,
  88.                       gint                 *width,
  89.                       gint                 *height);
  90.   void             (* render)        (GtkCellRenderer      *cell,
  91.                       GdkDrawable          *window,
  92.                       GtkWidget            *widget,
  93.                       GdkRectangle         *background_area,
  94.                       GdkRectangle         *cell_area,
  95.                       GdkRectangle         *expose_area,
  96.                       GtkCellRendererState  flags);
  97.   gboolean         (* activate)      (GtkCellRenderer      *cell,
  98.                       GdkEvent             *event,
  99.                       GtkWidget            *widget,
  100.                       const gchar          *path,
  101.                       GdkRectangle         *background_area,
  102.                       GdkRectangle         *cell_area,
  103.                       GtkCellRendererState  flags);
  104.   GtkCellEditable *(* start_editing) (GtkCellRenderer      *cell,
  105.                       GdkEvent             *event,
  106.                       GtkWidget            *widget,
  107.                       const gchar          *path,
  108.                       GdkRectangle         *background_area,
  109.                       GdkRectangle         *cell_area,
  110.                       GtkCellRendererState  flags);
  111.  
  112.   /* Signals */
  113.   void (* editing_canceled) (GtkCellRenderer *cell);
  114.   void (* editing_started)  (GtkCellRenderer *cell,
  115.                  GtkCellEditable *editable,
  116.                  const gchar     *path);
  117.  
  118.   /* Padding for future expansion */
  119.   void (*_gtk_reserved1) (void);
  120.   void (*_gtk_reserved2) (void);
  121. };
  122.  
  123. GType            gtk_cell_renderer_get_type       (void) G_GNUC_CONST;
  124.  
  125. void             gtk_cell_renderer_get_size       (GtkCellRenderer      *cell,
  126.                            GtkWidget            *widget,
  127.                            GdkRectangle         *cell_area,
  128.                            gint                 *x_offset,
  129.                            gint                 *y_offset,
  130.                            gint                 *width,
  131.                            gint                 *height);
  132. void             gtk_cell_renderer_render         (GtkCellRenderer      *cell,
  133.                            GdkWindow            *window,
  134.                            GtkWidget            *widget,
  135.                            GdkRectangle         *background_area,
  136.                            GdkRectangle         *cell_area,
  137.                            GdkRectangle         *expose_area,
  138.                            GtkCellRendererState  flags);
  139. gboolean         gtk_cell_renderer_activate       (GtkCellRenderer      *cell,
  140.                            GdkEvent             *event,
  141.                            GtkWidget            *widget,
  142.                            const gchar          *path,
  143.                            GdkRectangle         *background_area,
  144.                            GdkRectangle         *cell_area,
  145.                            GtkCellRendererState  flags);
  146. GtkCellEditable *gtk_cell_renderer_start_editing  (GtkCellRenderer      *cell,
  147.                            GdkEvent             *event,
  148.                            GtkWidget            *widget,
  149.                            const gchar          *path,
  150.                            GdkRectangle         *background_area,
  151.                            GdkRectangle         *cell_area,
  152.                            GtkCellRendererState  flags);
  153. void             gtk_cell_renderer_set_fixed_size (GtkCellRenderer      *cell,
  154.                            gint                  width,
  155.                            gint                  height);
  156. void             gtk_cell_renderer_get_fixed_size (GtkCellRenderer      *cell,
  157.                            gint                 *width,
  158.                            gint                 *height);
  159.  
  160. /* For use by cell renderer implementations only */
  161. #ifndef GTK_DISABLE_DEPRECATED
  162. void gtk_cell_renderer_editing_canceled (GtkCellRenderer *cell);
  163. #endif
  164. void gtk_cell_renderer_stop_editing     (GtkCellRenderer *cell,
  165.                          gboolean         canceled);
  166.  
  167.  
  168. G_END_DECLS
  169.  
  170. #endif /* __GTK_CELL_RENDERER_H__ */
  171.